/*
** $身份: 嘞辅库.h $
** 建造炉啊库的辅助函数
** 请参见 炉啊.h中的版权声明
*
** 本人所用声母表: a啊 b哔 c西 d迪 e鹅 f弗 g哥 
* h喝 i艾 j鸡 k颗 l嘞 m摸 n恩
* o欧 p匹 q气 r日 s丝 t嚏 
* u由 v微 w屋 x斯 y医 z只
*
* 一些英文单词缩写,我的翻译大多来自;有道词典,谷歌翻译,百度.
* 一些术语实在不好翻译,所以就原封不动.
* 
* 一些特有的表示特有库的术语是无法翻译的 *
* 否则编译器不能识别不能通过,第一版汉化就行不通.
* 
*/

#ifndef 嘞辅库_喝
#define 嘞辅库_喝


#include <stddef.h>
#include <stdio.h>

#include "炉啊.h"

/* 全局表 */
#define 炉啊_哥名字	"_哥"


typedef struct 炉啊嘞_缓冲 炉啊嘞_缓冲;

/* 额外错误码 '炉啊嘞_载文件斯' */
#define 炉啊_错误文件     (炉啊_错错+1)

/* 键,在寄存中,用于加载模块的表 */
#define 炉啊_已载入_表	"_已载入"

/* 键,在寄存中,用于预载入加载器的表 */
#define 炉啊_预载_表	"_预载"

typedef struct 炉啊嘞_寄 {
  const char *名字;
  炉啊_西函数 函;
} 炉啊嘞_寄;

#define 炉啊嘞_号大小	(sizeof(炉啊_整数)*16 + sizeof(炉啊_号码))

炉啊库_应用程序接口 void (炉啊嘞_检查版本_) (炉啊_国 *嘞, 炉啊_号码 版本, size_t 丝只);
#define 炉啊嘞_检查版本(嘞)  \
	  炉啊嘞_检查版本_(嘞, 炉啊_版本_号, 炉啊嘞_号大小)

炉啊库_应用程序接口 int (炉啊嘞_取元字段) (炉啊_国 *嘞, int 对象, const char *鹅);
炉啊库_应用程序接口 int (炉啊嘞_调用元) (炉啊_国 *嘞, int 对象, const char *鹅);
炉啊库_应用程序接口 const char *(炉啊嘞_到嘞串) (炉啊_国 *嘞, int 索引, size_t *长度);
炉啊库_应用程序接口 int (炉啊嘞_实参错误) (炉啊_国 *嘞, int 实参, const char *额外消息);
炉啊库_应用程序接口 int (炉啊嘞_类型错误) (炉啊_国 *嘞, int 实参, const char *嚏名字);
炉啊库_应用程序接口 const char *(炉啊嘞_检查嘞串) (炉啊_国 *嘞, int 实参,
                                                          size_t *嘞);
炉啊库_应用程序接口 const char *(炉啊嘞_选嘞串) (炉啊_国 *嘞, int 实参,
                                          const char *定义, size_t *嘞);
炉啊库_应用程序接口 炉啊_号码 (炉啊嘞_检查号码) (炉啊_国 *嘞, int 实参);
炉啊库_应用程序接口 炉啊_号码 (炉啊嘞_选号码) (炉啊_国 *嘞, int 实参, 炉啊_号码 定义);

炉啊库_应用程序接口 炉啊_整数 (炉啊嘞_检查整数) (炉啊_国 *嘞, int 实参);
炉啊库_应用程序接口 炉啊_整数 (炉啊嘞_选整数) (炉啊_国 *嘞, int 实参,
                                          炉啊_整数 定义);

炉啊库_应用程序接口 void (炉啊嘞_检查栈) (炉啊_国 *嘞, int 丝只, const char *消息);
炉啊库_应用程序接口 void (炉啊嘞_检查类型) (炉啊_国 *嘞, int 实参, int 嚏);
炉啊库_应用程序接口 void (炉啊嘞_检查任意) (炉啊_国 *嘞, int 实参);

炉啊库_应用程序接口 int   (炉啊嘞_新元表) (炉啊_国 *嘞, const char *嚏名字);
炉啊库_应用程序接口 void  (炉啊嘞_设置元表) (炉啊_国 *嘞, const char *嚏名字);
炉啊库_应用程序接口 void *(炉啊嘞_测试由数据) (炉啊_国 *嘞, int 由迪, const char *嚏名字);
炉啊库_应用程序接口 void *(炉啊嘞_检查由数据) (炉啊_国 *嘞, int 由迪, const char *嚏名字);

炉啊库_应用程序接口 void (炉啊嘞_哪里) (炉啊_国 *嘞, int 嘞微嘞);
炉啊库_应用程序接口 int (炉啊嘞_错误) (炉啊_国 *嘞, const char *格式, ...);

炉啊库_应用程序接口 int (炉啊嘞_检查选项) (炉啊_国 *嘞, int 实参, const char *定义,
                                   const char *const 列[]);

炉啊库_应用程序接口 int (炉啊嘞_文件结果) (炉啊_国 *嘞, int 州, const char *弗名字);
炉啊库_应用程序接口 int (炉啊嘞_执行结果) (炉啊_国 *嘞, int 州);

/* 预定义的引用 */
#define 炉啊_不引用       (-2)
#define 炉啊_引用零      (-1)

炉啊库_应用程序接口 int (炉啊嘞_引用) (炉啊_国 *嘞, int 嚏);
炉啊库_应用程序接口 void (炉啊嘞_反引用) (炉啊_国 *嘞, int 嚏, int 引用);

炉啊库_应用程序接口 int (炉啊嘞_载文件斯) (炉啊_国 *嘞, const char *文件名字,
                                               const char *模式);

#define 炉啊嘞_载文件(嘞,弗)	炉啊嘞_载文件斯(嘞,弗,NULL)

炉啊库_应用程序接口 int (炉啊嘞_载缓冲斯) (炉啊_国 *嘞, const char *缓冲冲, size_t 丝只,
                                   const char *名字, const char *模式);
炉啊库_应用程序接口 int (炉啊嘞_载串) (炉啊_国 *嘞, const char *丝);

炉啊库_应用程序接口 炉啊_国 *(炉啊嘞_新国) (void);

炉啊库_应用程序接口 炉啊_整数 (炉啊嘞_长度) (炉啊_国 *嘞, int 索引);

炉啊库_应用程序接口 void 炉啊嘞_加哥减 (炉啊嘞_缓冲 *哔, const char *丝,
                                     const char *匹, const char *日);
炉啊库_应用程序接口 const char *(炉啊嘞_哥减) (炉啊_国 *嘞, const char *丝,
                                    const char *匹, const char *日);

炉啊库_应用程序接口 void (炉啊嘞_设置函) (炉啊_国 *嘞, const 炉啊嘞_寄 *l, int 恩上);

炉啊库_应用程序接口 int (炉啊嘞_取减表) (炉啊_国 *嘞, int 索引, const char *弗名字);

炉啊库_应用程序接口 void (炉啊嘞_回溯) (炉啊_国 *嘞, 炉啊_国 *嘞1,
                                  const char *消息, int 级别);

炉啊库_应用程序接口 void (炉啊嘞_请求弗) (炉啊_国 *嘞, const char *模名字,
                                 炉啊_西函数 打开弗, int 全局);

/*
** ===============================================================
** 一些有用的宏
** ===============================================================
*/

#define 炉啊嘞_新库表(嘞,小嘞)	\
  炉啊_创建表(嘞, 0, sizeof(小嘞)/sizeof((小嘞)[0]) - 1)

#define 炉啊嘞_新库(嘞,小嘞)  \
  (炉啊嘞_检查版本(嘞), 炉啊嘞_新库表(嘞,小嘞), 炉啊嘞_设置函(嘞,小嘞,0))

#define 炉啊嘞_实参检查(嘞, 条件,实参,额外消息)	\
		((void)((条件) || 炉啊嘞_实参错误(嘞, (实参), (额外消息))))

#define 炉啊嘞_实参预期(嘞,条件,实参,嚏名字)	\
		((void)((条件) || 炉啊嘞_类型错误(嘞, (实参), (嚏名字))))

#define 炉啊嘞_检查串(嘞,恩)	(炉啊嘞_检查嘞串(嘞, (恩), NULL))
#define 炉啊嘞_选串(嘞,恩,迪)	(炉啊嘞_选嘞串(嘞, (恩), (迪), NULL))

#define 炉啊嘞_类型名字(嘞,艾)	炉啊_类型名字(嘞, 炉啊_类型(嘞,(艾)))

#define 炉啊嘞_做文件(嘞, 弗恩) \
	(炉啊嘞_载文件(嘞, 弗恩) || 炉啊_匹调用(嘞, 0, 炉啊_乘返, 0))

#define 炉啊嘞_做串(嘞, 丝) \
	(炉啊嘞_载串(嘞, 丝) || 炉啊_匹调用(嘞, 0, 炉啊_乘返, 0))

#define 炉啊嘞_取元表(嘞,恩)	(炉啊_取字段(嘞, 炉啊_寄存器索引, (恩)))

#define 炉啊嘞_选(嘞,弗,恩,迪)	(炉啊_是否没有或零(嘞,(恩)) ? (迪) : 弗(嘞,(恩)))

#define 炉啊嘞_载缓冲(嘞,丝,丝只,恩)	炉啊嘞_载缓冲斯(嘞,丝,丝只,恩,NULL)


/* 推用于表示 失败/错误 的值 */
#define 炉啊嘞_推失败(嘞)	炉啊_推零(嘞)

/*
** {======================================================
** 通用缓冲操作
** =======================================================
*/
struct 炉啊嘞_缓冲 {
  char *哔;  /* 缓冲地址 */
  size_t 大小;  /* 缓冲大小 */
  size_t 恩;  /* 缓冲区中的印刻号码 */
  炉啊_国 *嘞;
  union {
    炉啊艾_最大对齐;  /* 确保缓冲区的最大对齐 */
    char 哔[炉啊嘞_缓冲大小];  /* 初始缓冲 */
  } 初始;
};

#define 炉啊嘞_缓冲冲长度(哔弗)	((哔弗)->恩)
#define 炉啊嘞_缓冲冲地址(哔弗)	((哔弗)->哔)


#define 炉啊嘞_加印刻(哔,西) \
  ((void)((哔)->恩 < (哔)->大小 || 炉啊嘞_预备缓冲冲大小((哔), 1)), \
   ((哔)->小哔[(哔)->恩++] = (西)))

#define 炉啊嘞_加大小(哔,丝)	((哔)->恩 += (丝))

#define 炉啊嘞_缓冲冲减(哔,丝)	((哔)->恩 -= (丝))

炉啊库_应用程序接口 void (炉啊嘞_缓冲冲初始) (炉啊_国 *嘞, 炉啊嘞_缓冲 *哔);
炉啊库_应用程序接口 char *(炉啊嘞_预备缓冲冲大小) (炉啊嘞_缓冲 *哔, size_t 丝只);
炉啊库_应用程序接口 void (炉啊嘞_加嘞串) (炉啊嘞_缓冲 *哔, const char *丝, size_t 嘞);
炉啊库_应用程序接口 void (炉啊嘞_加串) (炉啊嘞_缓冲 *哔, const char *丝);
炉啊库_应用程序接口 void (炉啊嘞_加值) (炉啊嘞_缓冲 *哔);
炉啊库_应用程序接口 void (炉啊嘞_推结果) (炉啊嘞_缓冲 *哔);
炉啊库_应用程序接口 void (炉啊嘞_推结果大小) (炉啊嘞_缓冲 *哔, size_t 丝只);
炉啊库_应用程序接口 char *(炉啊嘞_缓冲冲初始大小) (炉啊_国 *嘞, 炉啊嘞_缓冲 *哔, size_t 丝只);

#define 炉啊嘞_预备缓冲(哔)	炉啊嘞_预备缓冲冲大小(哔, 炉啊嘞_缓冲大小)


/* }====================================================== */



/*
** {======================================================
** 入出库的文件句柄
** =======================================================
*/

/*
** 一个文件句柄是一个带有可元化  '炉啊_文件句柄' 的用户数据.
   初始结构 '炉啊嘞_流'
   (它可能在初始结构之后包含其他字段).
*/

#define 炉啊_文件句柄          "FILE*"


typedef struct 炉啊嘞_流 {
  FILE *f;  /* 流 ( NULL 表示未完全创建的流) */
  炉啊_西函数 关闭弗;  /* 去关闭流 ( NULL 表示已关闭的流) */
} 炉啊嘞_流;

/* }====================================================== */

/*
** {==================================================================
**  '抽象层' 用于消息和错误的基本报告
** ===================================================================
*/

/* 打印一个串 */
#if !defined(炉啊_写串)
#define 炉啊_写串(丝,嘞)   fwrite((丝), sizeof(char), (嘞), stdout)
#endif

/* 打印一个新行并刷新输出 */
#if !defined(炉啊_写行)
#define 炉啊_写行()        (炉啊_写串("\n", 1), fflush(stdout))
#endif

/* 打印错误信息 */
#if !defined(炉啊_写串错误)
#define 炉啊_写串错误(丝,匹) \
        (fprintf(stderr, (丝), (匹)), fflush(stderr))
#endif

/* }================================================================== */


/*
** {============================================================
** 与不赞成的转换的兼容性
** =============================================================
*/
#if defined(炉啊_兼容_应用程序接口整型投)

#define 炉啊嘞_检查无符号(嘞,啊)	((炉啊_无符号)炉啊嘞_检查整数(嘞,啊))
#define 炉啊嘞_选无符号(嘞,啊,迪)	\
	((炉啊_无符号)炉啊嘞_选整数(嘞,啊,(炉啊_整数)(迪)))

#define 炉啊嘞_检查整型(嘞,恩)	((int)炉啊嘞_检查整数(嘞, (恩)))
#define 炉啊嘞_选整型(嘞,恩,迪)	((int)炉啊嘞_选整数(嘞, (恩), (迪)))

#define 炉啊嘞_检查长型(嘞,恩)	((long)炉啊嘞_检查整数(嘞, (恩)))
#define 炉啊嘞_选长型(嘞,恩,迪)	((long)炉啊嘞_选整数(嘞, (恩), (迪)))

#endif
/* }============================================================ */



#endif